home *** CD-ROM | disk | FTP | other *** search
/ Aminet 3 / Aminet 3 - July 1994.iso / Aminet / util / misc / UserTool1_0.lha / UserTool / Source / funcs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-21  |  4.5 KB  |  219 lines

  1. /*
  2.  * UserTool - A Tool for managing users in a MuFS environment.
  3.  *
  4.  * $VER: funcs.c 37.1 (20.1.94)
  5.  */
  6.  
  7. #include <exec/memory.h>
  8. #include <clib/exec_protos.h>
  9.  
  10. #include <libraries/reqtools.h>
  11. #include <clib/reqtools_protos.h>
  12.  
  13. #include <libraries/gadtools.h>
  14. #include <clib/gadtools_protos.h>
  15.  
  16. #include <stdlib.h>
  17. #include <ctype.h>
  18.  
  19. #include "UserTool.h"
  20. #include "parse.h"
  21.  
  22. extern LONG Tags[];
  23. extern struct List *Users, *Groups;
  24. extern UserStruct *CurUser;
  25. extern GroupStruct *CurGroup;
  26.  
  27. LONG NodePos( struct List *List, struct Node *Node )
  28. {
  29.     struct Node *T;
  30.     LONG i = 0;
  31.  
  32.     for( T = List->lh_Head; T != Node; T = T->ln_Succ, i++ );
  33.  
  34.     return i;
  35. }
  36.  
  37. ULONG GetNextNumber( UBYTE *Str, LONG *Pos )
  38. {
  39.     UBYTE Number[256];
  40.     LONG NumPos = 0, InPos = *Pos;
  41.  
  42.     if( Str[InPos] == '\n' )
  43.         return -1;
  44.  
  45.     while(!( isdigit( Str[InPos] )))
  46.         if( Str[++InPos] == '\n' )
  47.             return -1;
  48.     
  49.     while( isdigit( Str[InPos] ))
  50.         Number[NumPos++] = Str[InPos++];
  51.     Number[NumPos] = '\0';
  52.     
  53.     *Pos = InPos;
  54.  
  55.     if( NumPos )
  56.         return (ULONG) atoi( Number );
  57.     
  58.     return -2;
  59. }
  60.  
  61. UserStruct *UserWithID( LONG UID )
  62. {
  63.     UserStruct *Tmp;
  64.  
  65.     for( Tmp = ( UserStruct * )Users->lh_Head; Tmp->us_Node.ln_Succ;
  66.         Tmp = ( UserStruct * )Tmp->us_Node.ln_Succ )
  67.         if( Tmp->us_UserID == UID )
  68.             return Tmp;
  69.  
  70.     Tags[7] = ( LONG )"Group Information";
  71.     rtEZRequest( "Illegal user UID:%ld.", "_Ok", 0L, ( struct TagItem * )Tags,
  72.                 UID );
  73.     return 0L;
  74. }
  75.  
  76. LONG UniqueID( UserStruct *User )
  77. {
  78.     UserStruct *TmpUser;
  79.  
  80.     for( TmpUser = ( UserStruct * )Users->lh_Head; TmpUser->us_Node.ln_Succ;
  81.         TmpUser = ( UserStruct * )TmpUser->us_Node.ln_Succ ) {
  82.         if(( TmpUser->us_UserID == User->us_UserID )&&( User != TmpUser ))
  83.             return 0L;
  84.     }
  85.  
  86.     return 1L;
  87. }
  88.  
  89. LONG GetNextUID( VOID )
  90. {
  91.     UserStruct *User;
  92.     LONG MaxID = 0;
  93.     
  94.     for( User = ( UserStruct * )Users->lh_Head; User->us_Node.ln_Succ;
  95.         User = ( UserStruct * )User->us_Node.ln_Succ )
  96.         if( User->us_UserID > MaxID && User->us_UserID < 65535 )
  97.            MaxID = User->us_UserID;
  98.            
  99.     return MaxID + 1;
  100. }
  101.  
  102. LONG GetNextGID( VOID )
  103. {
  104.     GroupStruct *Group;
  105.     LONG MaxID = 0;
  106.     
  107.     for( Group = ( GroupStruct * )Groups->lh_Head; Group->gs_Node.ln_Succ;
  108.         Group = ( GroupStruct * )Group->gs_Node.ln_Succ )
  109.         if( Group->gs_GID > MaxID )
  110.            MaxID = Group->gs_GID;
  111.            
  112.     return MaxID + 1;
  113. }
  114.  
  115. void UpdateMember( void )
  116. {
  117.     struct Node *Tmp;
  118.     LONG UserIsMember = 0;
  119.     
  120.     if( CurGroup ) {
  121.         for( Tmp = CurUser->us_Groups.lh_Head; Tmp->ln_Succ;
  122.             Tmp = Tmp->ln_Succ )
  123.             if( Tmp->ln_Pri == CurGroup->gs_GID ) {
  124.                 UserIsMember = 1;
  125.                 break;
  126.             }
  127.         
  128.         if( CurUser->us_UserID == CurGroup->gs_MgrID )
  129.             UserIsMember = 2;
  130.     }
  131.  
  132.     GT_SetGadgetAttrs( UserToolGadgets[GD_MEMBER], UserToolWnd, 0l,
  133.                       GTMX_Active, UserIsMember, TAG_DONE );
  134. }
  135.  
  136. void UpdateGadgets( LONG ListPos )
  137. {
  138.     LONG i;
  139.  
  140.     for( CurUser = ( UserStruct * )Users->lh_Head, i = 0;
  141.         i < ListPos;
  142.         i++, CurUser = ( UserStruct * )CurUser->us_Node.ln_Succ );
  143.     
  144.     GT_SetGadgetAttrs( UserToolGadgets[GD_USERID], UserToolWnd, 0L,
  145.                       GTIN_Number, CurUser->us_UserID, TAG_END );
  146.     GT_SetGadgetAttrs( UserToolGadgets[GD_REALNAME], UserToolWnd, 0L,
  147.                       GTST_String, CurUser->us_RealName, TAG_END );
  148.     GT_SetGadgetAttrs( UserToolGadgets[GD_HOMEDIR], UserToolWnd, 0L, 
  149.                       GTST_String, CurUser->us_HomeDir, TAG_END );
  150.     GT_SetGadgetAttrs( UserToolGadgets[GD_PORT], UserToolWnd, 0L,
  151.                       GTST_String, CurUser->us_Port, TAG_END );
  152.     UpdateMember();
  153. }
  154.  
  155. void UpdateGroups( LONG ListPos )
  156. {
  157.     LONG i;
  158.  
  159.     for( CurGroup = ( GroupStruct * )Groups->lh_Head, i = 0;
  160.         i < ListPos;
  161.         i++, CurGroup = ( GroupStruct * )CurGroup->gs_Node.ln_Succ );
  162.     
  163.     UpdateMember();
  164. }
  165.  
  166. VOID FreeUserList( struct List *FreeList )
  167. {
  168.     struct Node *FreeMe, *MeToo;
  169.  
  170.     while( FreeMe = RemHead( FreeList )) {
  171.         while( MeToo = RemHead( &(( UserStruct * )FreeMe )->us_Groups ))
  172.             FreeVec( MeToo );
  173.         FreeVec( FreeMe );
  174.     }
  175. }
  176.  
  177. VOID FreeGroupList( struct List *FreeList )
  178. {
  179.     struct Node *FreeMe;
  180.     
  181.     while( FreeMe = RemHead( FreeList ))
  182.         FreeVec( FreeMe );
  183. }
  184.  
  185. LONG AddGroupToUser( LONG UID, LONG GID )
  186. {
  187.     UserStruct *User;
  188.     struct Node *Group;
  189.     
  190.     if( User = UserWithID( UID )) {
  191.         if( Group = AllocVec( sizeof( struct Node ), MEMF_CLEAR )) {
  192.             Group->ln_Pri = GID;
  193.             Enqueue( &User->us_Groups, Group );
  194.             return 0L;
  195.         }
  196.     }
  197.  
  198.     return 1L;
  199. }
  200.  
  201. LONG RemoveGroupFromUser( LONG UID, LONG GID )
  202. {
  203.     UserStruct *User;
  204.     struct Node *Group;
  205.     
  206.     if( User = UserWithID( UID )) {
  207.         for( Group = User->us_Groups.lh_Head; Group->ln_Succ;
  208.             Group = Group->ln_Succ ) {
  209.             if( Group->ln_Pri == GID ) {
  210.                 Remove( Group );
  211.                 FreeVec( Group );
  212.                 return 0L;
  213.             }
  214.         }
  215.         return 2L;
  216.     } else
  217.         return 1L;
  218. }
  219.